#include "stdafx.h"
#include "CWindowsServices.h"
#include "EncodedPtr.h"
#include "_xptr_control.h"

extern int XcpTraceMonitorInitialize();
extern EncodedPtr<IPlatformServices> gps;

CWindowsServices::CWindowsServices(void)
{
}


CWindowsServices::~CWindowsServices(void)
{

}


#pragma region IPALDebuggingServices

void * CWindowsServices::XcpDebugAllocate( XUINT32 cSize, DebugAllocationClass allocationClass )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void * CWindowsServices::XcpDebugResize( void *pAddress, XUINT32 cSize, DebugAllocationClass allocationClass )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::XcpDebugFree( void *pAddress, DebugAllocationClass allocationClass )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::XcpCheckLeaks( XINT32 fSilent )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::XcpTrackAddRefRelease( void *pAddress, XUINT32 cRef )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::XcpDebugSetLeakDetectionFlag( void *pAddress, XINT32 fDisableLeakDetection )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::XcpVTrace( XUINT32 uClass, const XCHAR * pFilename, XINT32 iLine, XINT32 iValue, const XCHAR * pTestString, const XCHAR * pMessageString, void *pVArgs )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::XcpTrace( XUINT32 uClass, const XCHAR * pFilename, XINT32 iLine, XINT32 iValue, const XCHAR * pTestString, const XCHAR * pMessageString,... )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::YieldSlice()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetMonitorBuffer( MonitorBuffer **ppMonitorBuffer )
{
	throw std::logic_error("The method or operation is not implemented.");
}

IThreadMonitor * CWindowsServices::GetThreadMonitor()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::ReleaseMonitorBuffer( MonitorBuffer *pMonitorBuffer )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::InitializeThreadMonitoring()
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::DeleteThreadMonitoring()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::StringCchVPrintf( XCHAR * pString, XUINT32 cString, const XCHAR * pFormat, char * pVArgs )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::StringCchVPrintfA( char * pString, XUINT32 cString, const char * pFormat, char * pVArgs )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::YesNoMessageBox( XCHAR * pContent, const XCHAR * pTitle )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::XcpEnterSection( XUINT16 id )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::XcpLeaveSection( XUINT16 id )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::XcpPopToMark()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::XcpTraceMonitorInitialize( XBYTE testMode )
{
	return S_OK;
}

void CWindowsServices::XcpTraceMonitorShutdown()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::XcpTraceMonitorAttached()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CaptureStack( XUINT32 cMaxCallers, XUINT32 *pcCallers, XUINT64 **ppCallers, XUINT32 cIgnoreLevels )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetCallerSourceLocations( XUINT32 cCallers, XUINT64 *pCallers, ICallingMethod **ppCallingMethods )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::FreeCallingMethods( ICallingMethod *pCallers )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::BlockMemoryTrace( XINT32 bDisable )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::SetTraceMessageSink( IXcpTraceMessageSink *pTraceSink )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetTraceMessageSink( IXcpTraceMessageSink **ppTraceSink )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::XcpPerfMarker( XUINT64 lMarker )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::XcpPerfMarkerStringInfo( XUINT64 lMarker, XCHAR * szMarkerInfo )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::XcpPerfMarkerDwordInfo( XUINT64 lMarker, XCHAR * nMarkerInfo )
{
	throw std::logic_error("The method or operation is not implemented.");
}

_PerfMarkerType CWindowsServices::PerfMarkersEnabled()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::XcpRenderCountersInitialize()
{
	return S_OK;
}

HRESULT CWindowsServices::XcpRenderCountersIncrement( XUINT32 uCounter )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::DebugOutputSzNoEndl( const XCHAR * pFormattedMsg,... )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::DebugOutputSz( const XCHAR * pMessage )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::DebugAssertMessageBox( const XCHAR * pCondition, const XCHAR * pFile, XUINT32 nLine )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::DebugBreak()
{
	throw std::logic_error("The method or operation is not implemented.");
}

unsigned char CWindowsServices::TESTSignalMemLeak()
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::TESTSignalManagedMemLeak( XUINT32 *showAssert )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::TESTSignalASSERT( const XCHAR * pString )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::TESTSignalReferenceTrackerLeak()
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::FreeStackTrace( void *pCallers )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::IsDebuggerAttached( XBOOL *pfDebuggerAtached )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::SetTraceFlags( XUINT32 *pFlags )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::GetTraceFlags()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetTracingService( XTraceLevel level, XUINT32 suite, ITracingService **ppInterface )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetTracingService( ITracingService **ppInterface )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::IsTracingServiceEnabled( XTraceLevel level, XUINT32 suite )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::MediaTraceCreate( IPALReader *pReader, IPALMediaLayerTrace **ppTrace )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetDescriptionForMediaLog( XUINT32 *pBufferLength, XCHAR * pszBuffer )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT64 CWindowsServices::GetMemoryCount()
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::GetTrackerStressFromEnvironment( XUINT32 *pMaxIterations, XUINT32 *pStartIteration )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::EnableVisualTreeWalk( XUINT32 fEnable )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::ShouldWalkVisualTree()
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::EnableDirtyFlagsTreeWalk( XUINT32 fEnable )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::ShouldWalkDirtyFlagsTree()
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::EnableDumpSurface( XUINT32 fEnable )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::ShouldDumpSurface()
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::DumpSurface( IPALSurface * pSurface )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::EnableFullscreenPin( XUINT32 fEnable )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::ShouldPinFullscreen()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::WaitForManagedDebugger()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::ShowErrorDialog( const XCHAR * pszTitle, const XCHAR * pszError )
{
	throw std::logic_error("The method or operation is not implemented.");
}



#pragma endregion


#pragma region IPALMemoryServices

void * CWindowsServices::OSMemoryAllocate( XUINT32 cSize )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void * CWindowsServices::OSMemoryResize( void *pAddress, XUINT32 cSize )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::OSMemoryFree( void *pAddress )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::GetCurrentThreadId()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::MemoryCreate( IPALMalloc **ppMalloc )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::AllocatePages( XUINT32 cBytes, void **ppPages, XUINT32 flags )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::ReleasePages( XUINT32 cBytes, void *pPages )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::MarkPages( XUINT32 cBytes, void *pPages, XUINT32 flags )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreatePALMemoryFromBuffer( XUINT32 cbBuffer, XBYTE *pBuffer, IPALMemory **ppPALMemory )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetProcessOfferableHeap( IPALOfferableHeap **ppHeap )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::RegisterMemoryPressureCallbacks( XINT32 (__stdcall *pfnAddMemoryPressure ) (XUINT64), XINT32 (__stdcall *pfnRemoveMemoryPressure)(XUINT64) )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::UpdateAllocatedMemory( XINT64 cSize )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::ReportMemoryPressureToGC()
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::SetMemoryPressureReportingPolicy( XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}


static const XUINT32 s_uSizeOfControlBlockPool = 4096;

HRESULT CWindowsServices::GetSharedPointerControlBlockAllocator( XFixedSizeAllocator **ppAllocator )
{
	HRESULT hr = S_OK;
	IPALApplicationSingleton * pSingleton = NULL;

	XASSERT_FAILED_GOTO(gps->GetApplicationSingleton(&pSingleton),GASFAILED);


	if(this->m_pControlBlockAllocator)
	{
		*ppAllocator = this->m_pControlBlockAllocator;
		goto GASFAILED;
	}

	XASSERT_NOTNULL_FAILED_GOTO(this->m_pControlBlockAllocator = new XFixedSizeAllocator(),GASFAILED);

	
	XASSERT_FAILED_GOTO(this->m_pControlBlockAllocator->Initialize(sizeof(_xptr_control), s_uSizeOfControlBlockPool, 0, 1u),GASFAILED);
	*ppAllocator = this->m_pControlBlockAllocator;


GASFAILED:
	if ( pSingleton )
	{
		pSingleton->Release();
		pSingleton = NULL;
	}
	return hr;
}

HRESULT CWindowsServices::ReleaseSharedPointerControlBlockAllocator( XUINT32 *outLeakedItems )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::Delete( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::DeleteArray( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

#pragma endregion

#pragma region IPALURIServices

HRESULT CWindowsServices::UriCreate( XINT32 bCanonicalize, XUINT32 codepage, XUINT32 cString, char *pString, IPALUri **ppUri )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::UriCreate( XUINT32 cString, XCHAR * pString, IPALUri **ppUri )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::InterchangeUriAndPath( XCHAR * pSource, XUINT32 cSource, XCHAR * pTarget, XUINT32 *pcTarget, XUINT32 fToPath )
{
	throw std::logic_error("The method or operation is not implemented.");
}

#pragma endregion

#pragma region IPALMathServices

XINT64 CWindowsServices::MathFloor( long double rNum )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::MathFloorF( XFLOAT rNum )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT64 CWindowsServices::MathCeiling( long double rNum )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::MathCeilingF( XFLOAT rNum )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::MathIsFiniteF( XFLOAT rNum )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::MathIsNanF( XFLOAT rNum )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XDOUBLE CWindowsServices::MathSqrt( long double rNum )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XFLOAT CWindowsServices::MathSqrtF( XFLOAT rNum )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XDOUBLE CWindowsServices::MathLogarithm( long double eValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XDOUBLE CWindowsServices::MathExponent( long double ePower )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XFLOAT CWindowsServices::MathPower( XFLOAT eBase, XFLOAT ePower )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XFLOAT CWindowsServices::MathCos( XFLOAT eRadians )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XFLOAT CWindowsServices::MathSin( XFLOAT eRadians )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XFLOAT CWindowsServices::MathArcTan2( XFLOAT y, XFLOAT x )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XFLOAT CWindowsServices::MathCosDegrees( XFLOAT eDegrees )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XFLOAT CWindowsServices::MathSinDegrees( XFLOAT eDegrees )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XFLOAT CWindowsServices::MathTanDegrees( XFLOAT eDegrees )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XFLOAT CWindowsServices::MathLogarithm10( XFLOAT eValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XFLOAT CWindowsServices::MathArcTan( XFLOAT eRadians )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::MathRand()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateRegion( IPALRegion **ppRegion )
{
	throw std::logic_error("The method or operation is not implemented.");
}

#pragma endregion

#pragma region IPALStringServices
HRESULT CWindowsServices::ConvertString( XUINT32 cString, XCHAR * pString, long double *peValue, XCHAR * *ppString )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::ConvertDouble( long double eValue, XUINT32 cString, XCHAR * *ppString )
{
	throw std::logic_error("The method or operation is not implemented.");
}
#pragma endregion

#pragma region IPALPrintIOServices

HRESULT CWindowsServices::PrintStringCchA( char *pszDest, XUINT32 cchDest, const char *pszFormat,... )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PrintStringCchVA( char *pszDest, XUINT32 cchDest, const char *pszFormat,va_list vargs )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PrintStringCchExA( char *pszDest, XUINT32 cchDest, char **ppszDestEnd, XUINT32 *pcchRemaining, XUINT32 dwFlags, const char *pszFormat,... )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PrintStringCchExVA( char *pszDest, XUINT32 cchDest, char **ppszDestEnd, XUINT32 *pcchRemaining, XUINT32 dwFlags, const char *pszFormat, va_list vargs )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PrintStringCchW( XCHAR * pszDest, XUINT32 cchDest, const XCHAR * pszFormat,... )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PrintStringCchVW( XCHAR * pszDest, XUINT32 cchDest, const XCHAR * pszFormat,va_list vargs )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PrintStringCchExW( XCHAR * pszDest, XUINT32 cchDest, XCHAR * *ppszDestEnd, XUINT32 *pcchRemaining, XUINT32 dwFlags, const XCHAR * pszFormat,... )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PrintStringCchExVW( XCHAR * pszDest, XUINT32 cchDest, XCHAR * *ppszDestEnd, XUINT32 *pcchRemaining, XUINT32 dwFlags, const XCHAR * pszFormat, va_list vargs )
{
	throw std::logic_error("The method or operation is not implemented.");
}

#pragma endregion

#pragma region IPALThreadingServices
XINT32 CWindowsServices::InterlockedCompareExchange( XINT32 *pTarget, XINT32 Exchange, XINT32 Comperand )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void * CWindowsServices::PALInterlockedCompareExchangePointer( void **ppTarget, void *pExchange, void *pComperand )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void * CWindowsServices::PALInterlockedExchangePointer( void **ppTarget, void *pExchange )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::InterlockedDecrement( XINT32 *pnTarget )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::InterlockedExchange( XINT32 *pnTarget, XINT32 nValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::InterlockedExchangeAdd( XINT32 *pnTarget, XINT32 nValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::InterlockedIncrement( XINT32 *pnTarget )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CriticalSectionCreate( IPALCriticalSection **ppCritical )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::ThreadCreate( IPALWaitable **ppThread, XINT32 (__stdcall *pfn ) (char *), XUINT32 cData, char *pData )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::EventCreate( IPALEvent **ppEvent, XINT32 bSignaled, XINT32 bManual )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::SemaphoreCreate( IPALSemaphore **ppSemaphore, XUINT32 cMaxCount, XUINT32 cInitialCount )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::QueueCreate( IPALQueue **ppQueue, XUINT32 cMaxLength )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::SharedMemoryCreate( IPALMemory **ppSharedMemory, PAL_IPCInitMode initMode, XUINT32 bLowIntegrity, XUINT32 ulSize, CXString *pstrName )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::SharedMemoryDestroy( CXString * pstrName )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::NamedMutexCreate( IPALMutex **ppNamedMutex, PAL_IPCInitMode initMode, XUINT32 bLowIntegrity, XUINT32 bInitialOwner, CXString *pstrName )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::NamedMutexDestroy( CXString * pstrName )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::NamedEventCreate( IPALEvent **ppEvent, PAL_IPCInitMode initMode, XUINT32 bLowIntegrity, XUINT32 bInitialState, CXString *pstrName )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::NamedEventDestroy( CXString * pstrName )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::WaitForObjects( XUINT32 cWaitable, IPALWaitable **ppWaitable, XINT32 bAll, XUINT32 nTimeout )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PALSleep( XUINT32 dwMilliseconds )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::ThreadGetPriority( IPALWaitable *pThread )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::ThreadSetPriority( IPALWaitable *pThread, XINT32 nPriority )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XINT32 CWindowsServices::ProcessGetPriority()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::ProcessSetPriority( XINT32 nPriority )
{
	throw std::logic_error("The method or operation is not implemented.");
}

#pragma endregion

#pragma region IPALUIServices
HRESULT CWindowsServices::GetOpenFileName( void *, XINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetSaveFileName( void *, XINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::PALGetCaretBlinkTime()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::PALGetDoubleClickTime()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::PALGetDoubleClickDeltaX()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::PALGetDoubleClickDeltaY()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::ClipboardContainsText( XUINT32 *pContainsText )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetClipboardText( CXString **ppstrText, CXString **ppstrXaml )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::SetClipboardText( CXString *pstrText, CXString *pstrXaml )
{
	throw std::logic_error("The method or operation is not implemented.");
}

EndOfLineType::Enum CWindowsServices::GetEndOfLineType()
{
	throw std::logic_error("The method or operation is not implemented.");
}

#pragma endregion

#pragma region IPALTextServices
XEDITKEY CWindowsServices::TranslateEditKey( InputMessage *pMsg )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::PALSetIsInputMethodEditorEnabled( void *hWnd, XUINT32 fEnableIME )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::PALSetImeConversionMode( void *hWnd, XUINT32 conversionMode )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::PALSetImeState( void *hWnd, XUINT32 imeState )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::PALSetTextCompositionWindow( void *hWnd, XPOINTF point )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::PALCompleteTextComposition( void *hWnd )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PALGetTextCompositionString( void *hWnd, XUINT32 fResultString, CXString **ppstrText )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PALGetTextCompositionStringAttribute( void *hWnd, XINT32 **ppClauseInfo, XUINT32 *pClauseInfoCount, char **ppAttributes, XUINT32 *pAttributeCount )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PALGetTextCompositionPosition( void *hWnd, XUINT32 *pCaretPosition, XUINT32 *pDeltaPosition )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::PALSetInputMethodCandidateWindow( void *hWnd, XRECTF_WH rect, XPOINTF point )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::PALInputMethodConvertToHanja( void *hWnd, WCHAR charCode )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::PALIsReadingWindowIME()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PALGetLayoutLanguage( XUINT32 *pLangID )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateFontAndScriptServices( PALText::IFontAndScriptServicesFactory **ppFontAndScriptServices )
{
	throw std::logic_error("The method or operation is not implemented.");
}

#pragma endregion

#pragma region IPALCoreServices
HRESULT CWindowsServices::FileCreate( XUINT32 cFileName, XCHAR * pFileName, XINT32 fileOptions, IPALFile **ppFile )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetPlatformUtilities( IPlatformUtilities **ppInterface )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreatePowerAvailablityRequest( void ** )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::DisablePowerManagement( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::EnablePowerManagement( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::FreePowerAvailablityRequest( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT64 CWindowsServices::GetCPUTime()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT64 CWindowsServices::GetCPUMilliseconds()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetOSTime( XSYSTEMTIME *pTime )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateClock( IPALClock **ppIClock )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetNumberOfCPUCores( XUINT32 *pcProcessorCores )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::IsSupportedPlatform()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetRandomBytes( XUINT32 cbRandom, char *pRandom )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetApplicationSingleton( IPALApplicationSingleton **ppSingleton )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::GenerateSecurityToken()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetKeyboardModifiersState( XUINT32 *pModifiers )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::PerformanceFrequency( XINT64_LARGE_INTEGER *lpFrequency )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::PerformanceCounter( XINT64_LARGE_INTEGER *lpPerformanceCount )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CallCoInitializeMTA()
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::CallCoUninitialize()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetClientInformation( XINT32 *pcItems, XCHAR * *ppItems )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::IsOnRemoteDesktopSession( XUINT32 *pfOnRemoteDesktop )
{
	throw std::logic_error("The method or operation is not implemented.");
}

#pragma endregion


#pragma region IPALTouchInteractionServices
HRESULT CWindowsServices::IsDirectManipulationSupported( XUINT32 *isDirectManipulationSupported )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::IsPointerInfoValid( XUINT32 pointerId )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetTouchInteraction( IXcpTouchInteractionElement *pElement, XUINT32 bTabEnabled, XUINT32 bDoubleTabEnabled, XUINT32 bRightTabEnabled, XUINT32 bHoldEnabled, XUINT32 uiManipulationMode, IPALTouchInteraction **ppTouchInteraction )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetDirectManipulationService( IPALDirectManipulationService **ppDirectManipulationService )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetInputPaneInteraction( void *hWindow, IXcpInputPaneHandler *pInputPaneHandler, IPALInputPaneInteraction **ppInputPaneInteraction )
{
	throw std::logic_error("The method or operation is not implemented.");
}

#pragma endregion


#pragma region IPALCLRServices
HRESULT CWindowsServices::CreateCLRRuntimeHost( void *pRawAppDomain, ICoreServices *pCore )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateCLRRuntimeHost( ICLRRuntimeHost2 ** ppCLR, XCHAR * * ppszTrustedPath , XCHAR * * ppszPlatformAssembliesList, XCHAR * * ppszManifestBase, XCHAR * * ppszManifestFilePath )
{
	throw std::logic_error("The method or operation is not implemented.");
}
#pragma endregion

#pragma region IPALOfflineApplicationServices
HRESULT CWindowsServices::CreateOfflineApplicationStore( CXString *, XUINT32, IPALOfflineApplicationStore ** )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::RegisterOfflineApplication( const void *hwndOwner, const XCHAR * pszSite, const long double nUsedInMB, const long double nRequestedInMB )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::UnregisterOfflineApplication( CXString * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::LaunchOfflineApplication( CXString * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::RequestApplicationInstall( IXcpBrowserHost *, const void *, XUINT32, AuthenticodeSignatureResult, AuthenticodeTrustResult, IPALCertificate *, const XCHAR * , const XCHAR * , IPALMemory *, XINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetApplicationID( IPALUri *pXapUri, XUINT32 bRegister, CXString **ppstrAppID )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::DownloadUpdatedXap( IPALOfflineApplicationStore *pOfflineStore, CXString *pstrXapLastModified, int lLastModifiedFallback, IPALMemory **ppNewXap, CXString **ppstrNewXapLastModified )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XUINT32 CWindowsServices::IsRunningInOfflineLauncher()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CloseOfflineLauncher()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetRuntimeVersionCheckEnabled( XUINT32 *pbRuntimeVersionCheckEnabled )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::IsSeparateAppStoresSupported( XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}
#pragma endregion

#pragma region IPALRegkeyServices

HRESULT CWindowsServices::GetDefaultVideoCaptureDeviceIdentifier( CXString **ppDefaultDevice )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetDefaultAudioCaptureDeviceIdentifier( CXString **ppDefaultDevice )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::SetDefaultVideoCaptureDeviceIdentifier( CXString *pDefaultDevice )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::SetDefaultAudioCaptureDeviceIdentifier( CXString *pDefaultDevice )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetAllowAllWebcamAccess( XUINT32 *pbAllowAllWebcamAccess )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetAllowWebcam( XUINT32 *pbAllowWebcam )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetAllowInstallOfElevatedTrustApps( XUINT32 *pbAllowInstall )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetAllowLaunchOfElevatedTrustApps( XUINT32 *pbAllowLaunch )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetAllowElevatedTrustAppsInBrowser( XUINT32 *pbAllowEPInBrowser )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetAllowUdpMulticastClients( XUINT32 *pbAllowMulticast )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CheckForceGPUDecode( XUINT32 *pForceGPUVideoDecode )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetIsolatedStorageQuotaFromSettings( CXString *pstrDomainName, XUINT32 *pbSetQuotaToMax )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetClientInfoEnabled( XUINT32 *pfClientInfoEnabled )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetClientInfoAllowedDomains( CXString **ppAllowedDomains )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetIsolatedStorageInnerExceptionsAllowedDomains( CXString **ppAllowedDomains )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CheckEnableGPUVideoDecode( PAL_GPU_DECODE_STATE *peGPUDecodeState )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::SetEnableGPUVideoDecode( PAL_GPU_DECODE_STATE eGPUDecodeState )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetEnableFramerateCounter( XUINT32 *pfEnableFramerateCounter )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetEnableOverdrawHeatMap( XUINT32 *pfEnableOverdrawHeatMap )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::ReadPrimitiveCompositorFlags( XUINT32 *pFlags )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetPasswordRevealDisabled( XUINT32 *pfPasswordRevealDisabled )
{
	throw std::logic_error("The method or operation is not implemented.");
}

#pragma endregion

#pragma region IPALWebcamServices
HRESULT CWindowsServices::CreateCaptureGraph( IPALCaptureGraph **ppCaptureGraph )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateVideoCaptureDeviceEnumerator( IPALVideoCaptureDeviceEnumerator ** )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateAudioCaptureDeviceEnumerator( IPALAudioCaptureDeviceEnumerator ** )
{
	throw std::logic_error("The method or operation is not implemented.");
}

#pragma endregion

#pragma region IPALSettingsServices
HRESULT CWindowsServices::GetUserRoot( IPALSettingsDictionaryNode **ppSettingsNode )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetMachineRoot( IPALSettingsDictionaryNode **ppSettingsNode )
{
	throw std::logic_error("The method or operation is not implemented.");
}
#pragma endregion

#pragma region IPALFileSystemServices
HRESULT CWindowsServices::CreateFileFromUri( IPALUri *pUri, IPALFile **ppFile )
{
	throw std::logic_error("The method or operation is not implemented.");
}
#pragma endregion

#pragma region IPALPrintingServices
HRESULT CWindowsServices::CreatePrintingData( IPALPrintingData **ppPrintingData )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::LaunchPrintDialog( const void *, XUINT32 *, IPALPrintingData * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::StartDocument( IPALPrintingData *pPalPD )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PrintPage( void *pvBitmap, IPALPrintingData *pPalPD )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::PrintPostscriptPage( char *, XUINT32, IPALPrintingData * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::EndDocument( IPALPrintingData *pPalPD )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateD2DPrintFactoryAndTarget( IPALAcceleratedGraphicsFactory **ppPrintFactory, IPALPrintTarget **ppPALPrintTarget )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateD2DPrintingData( IPALD2DPrintingData **ppPrintingData )
{
	throw std::logic_error("The method or operation is not implemented.");
}

#pragma endregion

#pragma region IPALImagingServices
HRESULT CWindowsServices::CreateImageFactory( IPALImageFactory **ppFactory )
{
	throw std::logic_error("The method or operation is not implemented.");
}
#pragma endregion


void CWindowsServices::SetCanLoadAssembliesDomainNeutral( XUINT32 pValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

void CWindowsServices::SetCustomControlHostExists( XUINT32 pValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetSystemSetting( _SystemSettingsType setting, CValue *pValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetSystemColor( XINT32 colorIndex, XINT32 * pSysColor )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateGraphicsDeviceManager( IPALGraphicsDeviceManager **ppIGraphicsDeviceManager )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateSurfaceUpdatePoolMap( IPALSurfaceUpdatePoolMap **ppSurfaceUpdatePoolMap )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::ReaderCreate( IPALReader **ppReader )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::BrowserHostCreate( IXcpHostSite *pSite, IXcpDispatcher *pDispatcher, IXcpBrowserHost **ppHost )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::RequestQuota( const void * hwndOwner, const XCHAR * pszSite, const XDOUBLE nUsedInMB, const XDOUBLE nRequestedInMB )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::OutputProtectionCreate( IPALOutputProtectionUtilities * pUtilities, IPALOutputProtection * * ppOutputProtection, enum OutputProtectionOptions::Value Options )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::FetchAbsoluteUri( XUINT32 cAbsoluteUri, XCHAR * pAbsoluteUri, XINT32 (__stdcall *fnAbortQueryCallback ) (XUINT32, void *), XUINT32 cbAbortContext, char *pvAbortContext, XCHAR * sUserAgent, IPALDownloadResponse **ppiDownloadResponse )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateApplicationDataProvider( IPALApplicationDataProvider **ppAppDataProvider )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateWorkItemFactory( IPALWorkItemFactory **ppFactory )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::CreateIPALStreamFromIPALMemory( IPALMemory *pPALMemory, IPALStream **ppPALStream )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CWindowsServices::GetOfflineApplicationStoreDirectory( XUINT32, struct IPALDirectory * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}



